package org.jeecg.modules.wechatwork.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeewx.api.mp.aes.AesException;
import org.jeewx.api.mp.aes.WXBizMsgCrypt;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;


/**
 * WeChat Work 控制器
 * 
 * @author Your Name
 * @version 1.0.0
 */
@Slf4j
@Api(tags = "企业微信服务")
@RestController
@RequestMapping("/sys/thirdLogin")
@RequiredArgsConstructor
public class WechatWorkController {

    @Autowired
    private ISysUserService sysUserService;
    
    @Autowired
    private ISysDepartService sysDepartService;
    
    @Autowired
    private BaseCommonService baseCommonService;
    
    @Autowired
    private RedisUtil redisUtil;
    @Value("${qywechat.nurse.token:}")
    private String token;

    @Value("${qywechat.nurse.corpId:}")
    private String corpId;

    @Value("${qywechat.nurse.encodingAesKey:}")
    private String encodingAesKey;

    @Value("${qywechat.nurse.agentId1:}")
    private String agentId;

    @Value("${qywechat.nurse.secret1:}")
    private String secret;

    @Value("${qywechat.nurse.redirectUri:}")
    private String redirectUri;


   /**
           * 企业微信域名校验接口
     *
             * @param msgSignature 消息签名
     * @param timestamp 时间戳
     * @param nonce 随机数
     * @param echostr 加密的随机字符串
     * @param response HTTP响应
     */
    @GetMapping(value = "/test")
    public void verifyDomain(
            @RequestParam("msg_signature") String msgSignature,
            @RequestParam("timestamp") String timestamp,
            @RequestParam("nonce") String nonce,
            @RequestParam("echostr") String echostr,
            HttpServletResponse response) {

        PrintWriter out = null;
        try {
            out = response.getWriter();
System.out.println("进入方法！！");
            // 初始化加密工具类
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(
                    token,
                    encodingAesKey,
                    corpId
            );
            System.out.println("1"+token);
            System.out.println("2"+encodingAesKey);
            System.out.println("3"+corpId);
            System.out.println("4"+wxcpt);

            // 验证URL并解密echostr
            String result = wxcpt.verifyUrl(msgSignature, timestamp, nonce, echostr);

            // 验证成功，返回解密后的明文
            out.print(result);
            log.info("企业微信域名校验成功");
            System.out.println("1111");

        } catch (AesException e) {
            log.error("企业微信域名校验失败: {}", e.getMessage(), e);
            log.error("错误码: {}", e.getCode());
            System.out.println("222"+e.getCode());
        } catch (IOException e) {
            log.error("获取响应输出流失败", e);
            System.out.println("333");
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }

    /**
     * 企业微信OAuth2登录
     * 重定向到企业微信授权页面
     *
     * @param state 状态参数，用于回调时验证
     * @param response HTTP响应
     */
    @AutoLog(value = "企业微信-OAuth2登录")
    @GetMapping("/oauth2/wechat_enterprise/login")
    @ApiOperation(value = "企业微信OAuth2登录", notes = "重定向到企业微信授权页面进行登录")
    public void wechatEnterpriseLogin(
            @RequestParam(value = "state", required = false) String state,
            HttpServletResponse response) {
        try {
            System.out.println("=== 企业微信OAuth2登录流程开始 ===");
            log.info("=== 企业微信OAuth2登录流程开始 ===");
            System.out.println("接收到的state参数: " + state);
            log.info("接收到的state参数: {}", state);
            
            // 构建企业微信OAuth2授权URL
            String authUrl = buildWechatAuthUrl(state);
            System.out.println("构建的授权URL: " + authUrl);
            log.info("构建的授权URL: {}", authUrl);
            log.info("企业微信OAuth2登录，重定向到: {}", authUrl);
            
            // 重定向到企业微信授权页面
            System.out.println("准备重定向到企业微信授权页面");
            log.info("准备重定向到企业微信授权页面");
            response.sendRedirect(authUrl);
            System.out.println("重定向完成");
            log.info("重定向完成");
            
        } catch (IOException e) {
            System.out.println("重定向失败: " + e.getMessage());
            log.error("重定向失败: {}", e.getMessage());
            log.error("企业微信OAuth2登录重定向失败", e);
            try {
                response.getWriter().write("登录重定向失败，请稍后重试");
            } catch (IOException ioException) {
                log.error("写入响应失败", ioException);
            }
        }
    }

    /**
     * 企业微信OAuth2登录回调
     * 处理企业微信授权后的回调，实现完整的登录流程
     *
     * @param code 授权码
     * @param state 状态参数
     * @param request HTTP请求
     * @return 登录结果
     */
    @AutoLog(value = "企业微信-OAuth2登录回调")
    @GetMapping("/oauth2/wechat_enterprise/callback")
    @ApiOperation(value = "企业微信OAuth2登录回调", notes = "处理企业微信授权后的回调，实现完整的登录流程")
    public Result<JSONObject> wechatEnterpriseCallback(
            @RequestParam("code") String code,
            @RequestParam(value = "state", required = false) String state,
            HttpServletRequest request) {
        try {
            System.out.println("=== 企业微信OAuth2登录回调流程开始 ===");
            log.info("=== 企业微信OAuth2登录回调流程开始 ===");
            System.out.println("接收到的code: " + code);
            log.info("接收到的code: {}", code);
            System.out.println("接收到的state: " + state);
            log.info("接收到的state: {}", state);
            log.info("企业微信OAuth2登录回调，code: {}, state: {}", code, state);
            
            // 1. 调用企业微信API获取access_token
            System.out.println("步骤1: 开始获取access_token");
            log.info("步骤1: 开始获取access_token");
            String accessTokenUrl = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=" + corpId + "&corpsecret=" + secret;
            System.out.println("access_token请求URL: " + accessTokenUrl);
            log.info("access_token请求URL: {}", accessTokenUrl);
            String accessTokenResponse = String.valueOf(org.jeecg.common.util.RestUtil.get(accessTokenUrl));
            System.out.println("access_token响应: " + accessTokenResponse);
            log.info("access_token响应: {}", accessTokenResponse);
            JSONObject accessTokenJson = JSONObject.parseObject(accessTokenResponse);
            
            if (accessTokenJson.getInteger("errcode") != 0) {
                System.out.println("获取access_token失败: " + accessTokenJson.getString("errmsg"));
                log.error("获取access_token失败: {}", accessTokenJson.getString("errmsg"));
                throw new RuntimeException("获取access_token失败: " + accessTokenJson.getString("errmsg"));
            }
            
            String accessToken = accessTokenJson.getString("access_token");
            System.out.println("成功获取access_token: " + accessToken);
            log.info("成功获取access_token: {}", accessToken);
            
            // 2. 使用code和access_token获取用户信息
            System.out.println("步骤2: 开始获取用户信息");
            log.info("步骤2: 开始获取用户信息");
            String userInfoUrl = "https://qyapi.weixin.qq.com/cgi-bin/user/getuserinfo?access_token=" + accessToken + "&code=" + code;
            System.out.println("用户信息请求URL: " + userInfoUrl);
            log.info("用户信息请求URL: {}", userInfoUrl);
            String userInfoResponse = String.valueOf(org.jeecg.common.util.RestUtil.get(userInfoUrl));
            System.out.println("用户信息响应: " + userInfoResponse);
            log.info("用户信息响应: {}", userInfoResponse);
            
            // 检查响应是否为空
            if (org.jeecg.common.util.oConvertUtils.isEmpty(userInfoResponse) || "null".equals(userInfoResponse)) {
                System.out.println("用户信息响应为空");
                log.error("用户信息响应为空");
                return Result.error("企业微信用户信息获取失败，请重试");
            }
            
            JSONObject userInfoJson = JSONObject.parseObject(userInfoResponse);
            
            // 检查响应格式是否正确
            if (userInfoJson == null) {
                System.out.println("用户信息响应解析失败");
                log.error("用户信息响应解析失败");
                return Result.error("企业微信用户信息解析失败，请重试");
            }
            
            if (userInfoJson.getInteger("errcode") != 0) {
                System.out.println("获取用户信息失败: " + userInfoJson.getString("errmsg"));
                log.error("获取用户信息失败: {}", userInfoJson.getString("errmsg"));
                return Result.error("获取用户信息失败: " + userInfoJson.getString("errmsg"));
            }
            
            String wechatUserId = userInfoJson.getString("UserId");
            System.out.println("成功获取企业微信用户ID: " + wechatUserId);
            log.info("成功获取企业微信用户ID: {}", wechatUserId);
            
            // 检查企业微信用户ID是否为空
            if (org.jeecg.common.util.oConvertUtils.isEmpty(wechatUserId)) {
                System.out.println("企业微信用户ID为空，无法继续登录流程");
                log.error("企业微信用户ID为空，无法继续登录流程");
                return Result.error("企业微信用户ID获取失败，请重试或联系管理员");
            }
            
            log.info("企业微信登录成功，用户ID: {}", wechatUserId);
            
            // 3. 根据企业微信用户ID查找系统用户
            System.out.println("步骤3: 开始查找系统用户");
            log.info("步骤3: 开始查找系统用户");
            SysUser sysUser = findUserByWechatUserId(wechatUserId);
            if (sysUser == null) {
                System.out.println("未找到已绑定的系统用户，开始自动绑定流程");
                log.info("未找到已绑定的系统用户，开始自动绑定流程");
                // 如果用户不存在，尝试通过企业微信API获取用户详细信息进行自动绑定
                sysUser = autoBindUserByWechatInfo(wechatUserId, accessToken);
                if (sysUser == null) {
                    System.out.println("自动绑定失败，用户未绑定企业微信账号");
                    log.error("自动绑定失败，用户未绑定企业微信账号");
                    // 返回更详细的错误信息，包含解决建议
                    return Result.error("用户未绑定企业微信账号。\n" +
                        "解决方案：\n" +
                        "1. 请联系管理员手动绑定\n" +
                        "2. 确保企业微信用户信息中的手机号、邮箱或用户名与系统用户匹配\n" +
                        "3. 企业微信用户ID: " + wechatUserId);
                }
                System.out.println("自动绑定成功，找到系统用户: " + sysUser.getUsername());
                log.info("自动绑定成功，找到系统用户: {}", sysUser.getUsername());
            } else {
                System.out.println("找到已绑定的系统用户: " + sysUser.getUsername());
                log.info("找到已绑定的系统用户: {}", sysUser.getUsername());
            }
            
            // 4. 校验用户是否有效
            System.out.println("步骤4: 开始校验用户有效性");
            log.info("步骤4: 开始校验用户有效性");
            Result<?> checkResult = sysUserService.checkUserIsEffective(sysUser);
            if (!checkResult.isSuccess()) {
                System.out.println("用户有效性校验失败: " + checkResult.getMessage());
                log.error("用户有效性校验失败: {}", checkResult.getMessage());
                return Result.error(checkResult.getMessage());
            }
            System.out.println("用户有效性校验通过");
            log.info("用户有效性校验通过");
            
            // 5. 执行登录逻辑，参照系统登录流程
            System.out.println("步骤5: 开始执行登录逻辑");
            log.info("步骤5: 开始执行登录逻辑");
            Result<JSONObject> loginResult = new Result<>();
            loginResult = userInfo(sysUser, loginResult, request);
            System.out.println("登录逻辑执行完成");
            log.info("登录逻辑执行完成");
            
            // 6. 记录登录日志
            System.out.println("步骤6: 记录登录日志");
            log.info("步骤6: 记录登录日志");
            LoginUser loginUser = new LoginUser();
            BeanUtils.copyProperties(sysUser, loginUser);
            baseCommonService.addLog("企业微信用户: " + wechatUserId + " 登录成功！", CommonConstant.LOG_TYPE_1, null, loginUser);
            System.out.println("登录日志记录完成");
            log.info("登录日志记录完成");
            
            System.out.println("=== 企业微信OAuth2登录回调流程完成 ===");
            log.info("=== 企业微信OAuth2登录回调流程完成 ===");
            
            // 7. 获取token并返回登录结果
            System.out.println("步骤7: 获取token并返回登录结果");
            log.info("步骤7: 获取token并返回登录结果");
            
            // 获取token
            String token = loginResult.getResult().getString("token");
            System.out.println("获取到的token: " + token);
            log.info("获取到的token: {}", token);
            
            // 构建返回结果，只包含token
            JSONObject resultJson = new JSONObject();
            resultJson.put("token", token);
            resultJson.put("message", "企业微信登录成功");
            resultJson.put("loginType", "wechat_enterprise");
            
            System.out.println("返回的resultJson: " + resultJson.toJSONString());
            log.info("返回的resultJson: {}", resultJson.toJSONString());
            
            return Result.OK("企业微信登录成功", resultJson);
            
        } catch (Exception e) {
            System.out.println("企业微信OAuth2登录回调处理失败: " + e.getMessage());
            log.error("企业微信OAuth2登录回调处理失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("企业微信OAuth2登录回调处理失败", e);
            return Result.error("登录回调处理失败：" + e.getMessage());
        }
    }

    /**
     * 构建企业微信OAuth2授权URL
     *
     * @param state 状态参数
     * @return 授权URL
     */
    private String buildWechatAuthUrl(String state) {
        System.out.println("=== 构建企业微信授权URL ===");
        log.info("=== 构建企业微信授权URL ===");
        System.out.println("企业ID: " + corpId);
        log.info("企业ID: {}", corpId);
        System.out.println("应用ID: " + agentId);
        log.info("应用ID: {}", agentId);
        System.out.println("回调地址: " + redirectUri);
        log.info("回调地址: {}", redirectUri);
        System.out.println("状态参数: " + state);
        log.info("状态参数: {}", state);
        
        StringBuilder authUrl = new StringBuilder();
        authUrl.append("https://open.weixin.qq.com/connect/oauth2/authorize?");
        authUrl.append("appid=").append(corpId);
        authUrl.append("&redirect_uri=").append(URLEncoder.encode(redirectUri, StandardCharsets.UTF_8));
        authUrl.append("&response_type=code");
        authUrl.append("&scope=snsapi_base");
        authUrl.append("&agentid=").append(agentId);
        
        if (state != null && !state.trim().isEmpty()) {
            authUrl.append("&state=").append(URLEncoder.encode(state, StandardCharsets.UTF_8));
        }
        
        authUrl.append("#wechat_redirect");
        
        String finalUrl = authUrl.toString();
        System.out.println("构建完成的授权URL: " + finalUrl);
        log.info("构建完成的授权URL: {}", finalUrl);
        return finalUrl;
    }

    /**
     * 根据企业微信用户ID查找系统用户
     * 通过SysUser表的wechatUserid字段进行关联
     *
     * @param wechatUserId 企业微信用户ID
     * @return 系统用户
     */
    private SysUser findUserByWechatUserId(String wechatUserId) {
        try {
            System.out.println("=== 查找系统用户 ===");
            log.info("=== 查找系统用户 ===");
            System.out.println("企业微信用户ID: " + wechatUserId);
            log.info("企业微信用户ID: {}", wechatUserId);
            
            // 通过wechatUserid字段查找系统用户
            LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUser::getWechatUserid, wechatUserId);
            SysUser user = sysUserService.getOne(queryWrapper);
            
            if (user != null) {
                System.out.println("找到已绑定的系统用户: " + user.getUsername());
                log.info("找到已绑定的系统用户: {}", user.getUsername());
                return user;
            }
            
            System.out.println("未找到已绑定的系统用户");
            log.info("未找到已绑定的系统用户");
            return null;
            
        } catch (Exception e) {
            System.out.println("查找企业微信用户失败: " + e.getMessage());
            log.error("查找企业微信用户失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("查找企业微信用户失败", e);
            return null;
        }
    }

    /**
     * 通过企业微信用户信息自动绑定系统用户
     * 调用企业微信API获取用户详细信息，然后通过手机号或邮箱匹配系统用户
     *
     * @param wechatUserId 企业微信用户ID
     * @param accessToken 企业微信访问令牌
     * @return 系统用户
     */
    private SysUser autoBindUserByWechatInfo(String wechatUserId, String accessToken) {
        try {
            System.out.println("=== 自动绑定用户流程开始 ===");
            System.out.println("企业微信用户ID: " + wechatUserId);
            System.out.println("访问令牌: " + accessToken);
            
            // 1. 调用企业微信API获取用户详细信息
            System.out.println("步骤1: 调用企业微信API获取用户详细信息");
            String userDetailUrl = "https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=" + accessToken + "&userid=" + wechatUserId;
            System.out.println("用户详情请求URL: " + userDetailUrl);
            String userDetailResponse = String.valueOf(org.jeecg.common.util.RestUtil.get(userDetailUrl));
            System.out.println("用户详情响应: " + userDetailResponse);
            JSONObject userDetailJson = JSONObject.parseObject(userDetailResponse);
            
            if (userDetailJson.getInteger("errcode") != 0) {
                System.out.println("获取企业微信用户详细信息失败: " + userDetailJson.getString("errmsg"));
                log.error("获取企业微信用户详细信息失败: {}", userDetailJson.getString("errmsg"));
                return null;
            }
            
            // 2. 解析用户信息
            System.out.println("步骤2: 解析用户信息");
            log.info("步骤2: 解析用户信息");
            String mobile = userDetailJson.getString("mobile");
            String email = userDetailJson.getString("email");
            String name = userDetailJson.getString("name");
            
            System.out.println("企业微信用户信息 - ID: " + wechatUserId + ", 姓名: " + name + ", 手机: " + mobile + ", 邮箱: " + email);
            log.info("企业微信用户信息 - ID: {}, 姓名: {}, 手机: {}, 邮箱: {}", wechatUserId, name, mobile, email);
            
            // 3. 通过手机号查找系统用户
            System.out.println("步骤3: 通过手机号查找系统用户");
            log.info("步骤3: 通过手机号查找系统用户");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(mobile)) {
                System.out.println("尝试通过手机号匹配: " + mobile);
                log.info("尝试通过手机号匹配: {}", mobile);
                LambdaQueryWrapper<SysUser> mobileQuery = new LambdaQueryWrapper<>();
                mobileQuery.eq(SysUser::getPhone, mobile);
                SysUser mobileUser = sysUserService.getOne(mobileQuery);
                
                if (mobileUser != null) {
                    System.out.println("通过手机号找到系统用户: " + mobileUser.getUsername());
                    log.info("通过手机号找到系统用户: {}", mobileUser.getUsername());
                    // 自动绑定
                    mobileUser.setWechatUserid(wechatUserId);
                    sysUserService.updateById(mobileUser);
                    System.out.println("通过手机号自动绑定成功: " + mobile + " -> " + wechatUserId);
                    log.info("通过手机号自动绑定成功: {} -> {}", mobile, wechatUserId);
                    log.info("通过手机号自动绑定用户: {} -> {}", mobile, wechatUserId);
                    return mobileUser;
                } else {
                    System.out.println("通过手机号未找到匹配的系统用户");
                    log.info("通过手机号未找到匹配的系统用户");
                }
            } else {
                System.out.println("企业微信用户手机号为空，跳过手机号匹配");
                log.info("企业微信用户手机号为空，跳过手机号匹配");
            }
            
            // 4. 通过邮箱查找系统用户
            System.out.println("步骤4: 通过邮箱查找系统用户");
            log.info("步骤4: 通过邮箱查找系统用户");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(email)) {
                System.out.println("尝试通过邮箱匹配: " + email);
                log.info("尝试通过邮箱匹配: {}", email);
                LambdaQueryWrapper<SysUser> emailQuery = new LambdaQueryWrapper<>();
                emailQuery.eq(SysUser::getEmail, email);
                SysUser emailUser = sysUserService.getOne(emailQuery);
                
                if (emailUser != null) {
                    System.out.println("通过邮箱找到系统用户: " + emailUser.getUsername());
                    log.info("通过邮箱找到系统用户: {}", emailUser.getUsername());
                    // 自动绑定
                    emailUser.setWechatUserid(wechatUserId);
                    sysUserService.updateById(emailUser);
                    System.out.println("通过邮箱自动绑定成功: " + email + " -> " + wechatUserId);
                    log.info("通过邮箱自动绑定成功: {} -> {}", email, wechatUserId);
                    log.info("通过邮箱自动绑定用户: {} -> {}", email, wechatUserId);
                    return emailUser;
                } else {
                    System.out.println("通过邮箱未找到匹配的系统用户");
                    log.info("通过邮箱未找到匹配的系统用户");
                }
            } else {
                System.out.println("企业微信用户邮箱为空，跳过邮箱匹配");
                log.info("企业微信用户邮箱为空，跳过邮箱匹配");
            }
            
            // 5. 通过用户名查找系统用户（如果企业微信用户ID就是系统用户名）
            System.out.println("步骤5: 通过用户名查找系统用户");
            log.info("步骤5: 通过用户名查找系统用户");
            System.out.println("尝试通过用户名匹配: " + wechatUserId);
            log.info("尝试通过用户名匹配: {}", wechatUserId);
            LambdaQueryWrapper<SysUser> usernameQuery = new LambdaQueryWrapper<>();
            usernameQuery.eq(SysUser::getUsername, wechatUserId);
            SysUser usernameUser = sysUserService.getOne(usernameQuery);
            
            if (usernameUser != null) {
                System.out.println("通过用户名找到系统用户: " + usernameUser.getUsername());
                log.info("通过用户名找到系统用户: {}", usernameUser.getUsername());
                // 自动绑定
                usernameUser.setWechatUserid(wechatUserId);
                sysUserService.updateById(usernameUser);
                System.out.println("通过用户名自动绑定成功: " + wechatUserId + " -> " + wechatUserId);
                log.info("通过用户名自动绑定成功: {} -> {}", wechatUserId, wechatUserId);
                log.info("通过用户名自动绑定用户: {} -> {}", wechatUserId, wechatUserId);
                return usernameUser;
            } else {
                System.out.println("通过用户名未找到匹配的系统用户");
                log.info("通过用户名未找到匹配的系统用户");
            }
            
            // 6. 通过姓名查找系统用户（如果企业微信用户姓名与系统用户姓名匹配）
            System.out.println("步骤6: 通过姓名查找系统用户");
            log.info("步骤6: 通过姓名查找系统用户");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(name)) {
                System.out.println("尝试通过姓名匹配: " + name);
                log.info("尝试通过姓名匹配: {}", name);
                LambdaQueryWrapper<SysUser> nameQuery = new LambdaQueryWrapper<>();
                nameQuery.eq(SysUser::getRealname, name);
                SysUser nameUser = sysUserService.getOne(nameQuery);
                
                if (nameUser != null) {
                    System.out.println("通过姓名找到系统用户: " + nameUser.getUsername());
                    log.info("通过姓名找到系统用户: {}", nameUser.getUsername());
                    // 自动绑定
                    nameUser.setWechatUserid(wechatUserId);
                    sysUserService.updateById(nameUser);
                    System.out.println("通过姓名自动绑定成功: " + name + " -> " + wechatUserId);
                    log.info("通过姓名自动绑定成功: {} -> {}", name, wechatUserId);
                    log.info("通过姓名自动绑定用户: {} -> {}", name, wechatUserId);
                    return nameUser;
                } else {
                    System.out.println("通过姓名未找到匹配的系统用户");
                    log.info("通过姓名未找到匹配的系统用户");
                }
            } else {
                System.out.println("企业微信用户姓名为空，跳过姓名匹配");
                log.info("企业微信用户姓名为空，跳过姓名匹配");
            }
            
            // 7. 如果所有匹配方式都失败，尝试自动创建系统用户
            System.out.println("步骤7: 尝试自动创建系统用户");
            log.info("步骤7: 尝试自动创建系统用户");
            SysUser newUser = createSystemUserFromWechatInfo(wechatUserId, name, mobile, email);
            if (newUser != null) {
                System.out.println("自动创建系统用户成功: " + newUser.getUsername());
                log.info("自动创建系统用户成功: {}", newUser.getUsername());
                return newUser;
            }
            
            System.out.println("无法找到匹配的系统用户进行自动绑定，企业微信用户ID: " + wechatUserId);
            log.warn("无法找到匹配的系统用户进行自动绑定，企业微信用户ID: {}", wechatUserId);
            return null;
            
        } catch (Exception e) {
            System.out.println("自动绑定企业微信用户失败: " + e.getMessage());
            log.error("自动绑定企业微信用户失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("自动绑定企业微信用户失败", e);
            return null;
        }
    }

    /**
     * 根据企业微信用户信息自动创建系统用户
     * 当无法找到匹配的系统用户时，自动创建新用户并绑定企业微信账号
     *
     * @param wechatUserId 企业微信用户ID
     * @param name 企业微信用户姓名
     * @param mobile 企业微信用户手机号
     * @param email 企业微信用户邮箱
     * @return 新创建的系统用户
     */
    private SysUser createSystemUserFromWechatInfo(String wechatUserId, String name, String mobile, String email) {
        try {
            System.out.println("=== 自动创建系统用户流程开始 ===");
            log.info("=== 自动创建系统用户流程开始 ===");
            System.out.println("企业微信用户ID: " + wechatUserId);
            log.info("企业微信用户ID: {}", wechatUserId);
            System.out.println("企业微信用户姓名: " + name);
            log.info("企业微信用户姓名: {}", name);
            System.out.println("企业微信用户手机号: " + mobile);
            log.info("企业微信用户手机号: {}", mobile);
            System.out.println("企业微信用户邮箱: " + email);
            log.info("企业微信用户邮箱: {}", email);
            
            // 1. 生成系统用户名
            System.out.println("步骤1: 生成系统用户名");
            log.info("步骤1: 生成系统用户名");
            String username = generateUsername(wechatUserId, name, mobile);
            System.out.println("生成的用户名: " + username);
            log.info("生成的用户名: {}", username);
            
            // 2. 检查用户名是否已存在
            System.out.println("步骤2: 检查用户名是否已存在");
            log.info("步骤2: 检查用户名是否已存在");
            LambdaQueryWrapper<SysUser> checkWrapper = new LambdaQueryWrapper<>();
            checkWrapper.eq(SysUser::getUsername, username);
            SysUser existUser = sysUserService.getOne(checkWrapper);
            if (existUser != null) {
                System.out.println("用户名已存在，尝试其他用户名");
                log.warn("用户名已存在，尝试其他用户名: {}", username);
                // 如果用户名已存在，添加数字后缀
                int suffix = 1;
                String newUsername;
                do {
                    newUsername = username + "_" + suffix;
                    checkWrapper = new LambdaQueryWrapper<>();
                    checkWrapper.eq(SysUser::getUsername, newUsername);
                    existUser = sysUserService.getOne(checkWrapper);
                    suffix++;
                } while (existUser != null && suffix <= 10);
                
                if (existUser != null) {
                    System.out.println("无法生成唯一用户名，创建失败");
                    log.error("无法生成唯一用户名，创建失败");
                    return null;
                }
                username = newUsername;
                System.out.println("使用新用户名: " + username);
                log.info("使用新用户名: {}", username);
            }
            
            // 3. 创建系统用户
            System.out.println("步骤3: 创建系统用户");
            log.info("步骤3: 创建系统用户");
            SysUser newUser = new SysUser();
            newUser.setUsername(username);
            newUser.setRealname(name != null ? name : wechatUserId);
            newUser.setPhone(mobile);
            newUser.setEmail(email);
            newUser.setWechatUserid(wechatUserId);
            
            // 设置默认密码（企业微信登录用户使用随机密码）
            String defaultPassword = generateDefaultPassword();
            String salt = org.jeecg.common.util.oConvertUtils.randomGen(8);
            String encryptedPassword = org.jeecg.common.util.PasswordUtil.encrypt(username, defaultPassword, salt);
            newUser.setPassword(encryptedPassword);
            newUser.setSalt(salt);
            
            // 设置默认状态
            newUser.setStatus(1); // 启用状态
            newUser.setDelFlag(0); // 未删除
            newUser.setCreateTime(new java.util.Date());
            newUser.setUpdateTime(new java.util.Date());
            
            // 设置默认部门
            System.out.println("步骤4: 设置默认部门");
            log.info("步骤4: 设置默认部门");
            String defaultOrgCode = "A01";
            String defaultOrgName = "华声康护信息平台";
            
            // 确保默认部门存在
            String deptId = ensureDefaultDepartment(defaultOrgCode, defaultOrgName);
            if (deptId != null) {
                newUser.setOrgCode(defaultOrgCode);
                System.out.println("设置默认部门编码: " + defaultOrgCode);
                log.info("设置默认部门编码: {}", defaultOrgCode);
                System.out.println("设置默认部门名称: " + defaultOrgName);
                log.info("设置默认部门名称: {}", defaultOrgName);
            } else {
                System.out.println("默认部门设置失败，使用空值");
                log.warn("默认部门设置失败，使用空值");
            }
            
            // 保存用户
            System.out.println("步骤5: 保存系统用户");
            log.info("步骤5: 保存系统用户");
            boolean saveResult = sysUserService.save(newUser);
            if (!saveResult) {
                System.out.println("保存系统用户失败");
                log.error("保存系统用户失败");
                return null;
            }
            
            // 设置用户角色
            System.out.println("步骤6: 设置用户角色");
            log.info("步骤6: 设置用户角色");
            boolean roleResult = setUserDefaultRole(newUser);
            if (!roleResult) {
                System.out.println("设置用户角色失败");
                log.warn("设置用户角色失败");
            }
            
            System.out.println("系统用户创建成功，用户ID: " + newUser.getId());
            log.info("系统用户创建成功，用户ID: {}", newUser.getId());
            log.info("自动创建系统用户: {} -> {}", username, wechatUserId);
            
            return newUser;
            
        } catch (Exception e) {
            System.out.println("自动创建系统用户失败: " + e.getMessage());
            log.error("自动创建系统用户失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("自动创建系统用户失败", e);
            return null;
        }
    }

    /**
     * 生成系统用户名
     * 优先级：企业微信用户ID > 姓名拼音 > 手机号 > 随机字符串
     *
     * @param wechatUserId 企业微信用户ID
     * @param name 企业微信用户姓名
     * @param mobile 企业微信用户手机号
     * @return 生成的用户名
     */
    private String generateUsername(String wechatUserId, String name, String mobile) {
        try {
            System.out.println("=== 生成系统用户名 ===");
            log.info("=== 生成系统用户名 ===");
            System.out.println("企业微信用户ID: " + wechatUserId);
            log.info("企业微信用户ID: {}", wechatUserId);
            System.out.println("企业微信用户姓名: " + name);
            log.info("企业微信用户姓名: {}", name);
            System.out.println("企业微信用户手机号: " + mobile);
            log.info("企业微信用户手机号: {}", mobile);
            
            // 1. 优先使用企业微信用户ID（如果符合用户名规范）
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(wechatUserId) && 
                isValidUsername(wechatUserId)) {
                String username = wechatUserId.toLowerCase();
                System.out.println("使用企业微信用户ID作为用户名: " + username);
                log.info("使用企业微信用户ID作为用户名: {}", username);
                return username;
            }
            
            // 2. 使用姓名拼音（如果姓名不为空）
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(name)) {
                String pinyinUsername = convertToPinyin(name);
                if (org.jeecg.common.util.oConvertUtils.isNotEmpty(pinyinUsername) && 
                    isValidUsername(pinyinUsername)) {
                    String username = pinyinUsername.toLowerCase();
                    System.out.println("使用姓名拼音作为用户名: " + username);
                    log.info("使用姓名拼音作为用户名: {}", username);
                    return username;
                }
            }
            
            // 3. 使用手机号（如果手机号不为空）
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(mobile)) {
                // 手机号作为用户名时，添加前缀
                String username = "user_" + mobile;
                System.out.println("使用手机号作为用户名: " + username);
                log.info("使用手机号作为用户名: {}", username);
                return username;
            }
            
            // 4. 生成随机用户名
            String username = "user_" + org.jeecg.common.util.oConvertUtils.randomGen(8);
            System.out.println("生成随机用户名: " + username);
            log.info("生成随机用户名: {}", username);
            return username;
            
        } catch (Exception e) {
            System.out.println("生成用户名失败: " + e.getMessage());
            log.error("生成用户名失败: {}", e.getMessage());
            log.error("生成用户名失败", e);
            String fallbackUsername = "user_" + org.jeecg.common.util.oConvertUtils.randomGen(8);
            System.out.println("使用备用用户名: " + fallbackUsername);
            log.info("使用备用用户名: {}", fallbackUsername);
            return fallbackUsername;
        }
    }

    /**
     * 验证用户名是否符合规范
     * 用户名只能包含字母、数字、下划线，长度3-20位
     *
     * @param username 用户名
     * @return 是否符合规范
     */
    private boolean isValidUsername(String username) {
        if (org.jeecg.common.util.oConvertUtils.isEmpty(username)) {
            System.out.println("用户名验证失败: 用户名为空");
            log.warn("用户名验证失败: 用户名为空");
            return false;
        }
        // 用户名长度3-20位，只能包含字母、数字、下划线
        boolean isValid = username.matches("^[a-zA-Z0-9_]{3,20}$");
        if (isValid) {
            System.out.println("用户名验证通过: " + username);
            log.info("用户名验证通过: {}", username);
        } else {
            System.out.println("用户名验证失败: " + username + " (不符合规范)");
            log.warn("用户名验证失败: {} (不符合规范)", username);
        }
        return isValid;
    }

    /**
     * 将中文姓名转换为拼音
     * 这里使用简单的转换，实际项目中可以使用更专业的拼音转换库
     *
     * @param name 中文姓名
     * @return 拼音用户名
     */
    private String convertToPinyin(String name) {
        try {
            System.out.println("开始拼音转换: " + name);
            log.info("开始拼音转换: {}", name);
            
            // 这里使用简单的映射，实际项目中建议使用专业的拼音转换库
            // 如 pinyin4j 等
            java.util.Map<String, String> pinyinMap = new java.util.HashMap<>();
            pinyinMap.put("黎", "li");
            pinyinMap.put("航", "hang");
            pinyinMap.put("张", "zhang");
            pinyinMap.put("三", "san");
            pinyinMap.put("李", "li");
            pinyinMap.put("四", "si");
            pinyinMap.put("王", "wang");
            pinyinMap.put("五", "wu");
            // 可以继续添加更多映射
            
            StringBuilder pinyin = new StringBuilder();
            for (char c : name.toCharArray()) {
                String pinyinChar = pinyinMap.get(String.valueOf(c));
                if (pinyinChar != null) {
                    pinyin.append(pinyinChar);
                    System.out.println("字符 '" + c + "' 转换为拼音: " + pinyinChar);
                    log.info("字符 '{}' 转换为拼音: {}", c, pinyinChar);
                } else {
                    // 如果不是中文字符，直接使用
                    if (Character.isLetterOrDigit(c)) {
                        pinyin.append(c);
                        System.out.println("字符 '" + c + "' 直接使用");
                        log.info("字符 '{}' 直接使用", c);
                    } else {
                        System.out.println("字符 '" + c + "' 跳过");
                        log.info("字符 '{}' 跳过", c);
                    }
                }
            }
            
            String result = pinyin.toString();
            System.out.println("拼音转换完成: " + name + " -> " + result);
            log.info("拼音转换完成: {} -> {}", name, result);
            return result;
            
        } catch (Exception e) {
            System.out.println("拼音转换失败: " + e.getMessage());
            log.error("拼音转换失败: {}", e.getMessage());
            log.error("拼音转换失败", e);
            return null;
        }
    }

    /**
     * 生成默认密码
     * 企业微信登录用户使用随机密码，因为不需要密码登录
     *
     * @return 默认密码
     */
    private String generateDefaultPassword() {
        // 生成16位随机密码
        String password = org.jeecg.common.util.oConvertUtils.randomGen(16);
        System.out.println("生成默认密码: " + password);
        log.info("生成默认密码: {}", password);
        return password;
    }


    /**
     * 确定跳转目标页面
     * 优先级：state参数 > 用户角色 > 部门 > 默认页面
     *
     * @param state 状态参数
     * @param username 用户名
     * @param realname 真实姓名
     * @param orgCode 部门编码
     * @param userInfo 用户信息
     * @return 跳转目标页面
     */
    private String determineRedirectUrl(String state, String username, String realname, String orgCode, JSONObject userInfo) {
        try {
            System.out.println("=== 确定跳转目标页面 ===");
            log.info("=== 确定跳转目标页面 ===");
            
            // 1. 优先使用state参数中的跳转地址
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(state)) {
                try {
                    String decodedState = java.net.URLDecoder.decode(state, "UTF-8");
                    System.out.println("使用state参数中的跳转地址: " + decodedState);
                    log.info("使用state参数中的跳转地址: {}", decodedState);
                    return decodedState;
                } catch (Exception e) {
                    System.out.println("解析state参数失败: " + e.getMessage());
                    log.warn("解析state参数失败: {}", e.getMessage());
                }
            }
            
            // 2. 根据用户名确定跳转页面
            String urlByUsername = getRedirectUrlByUsername(username);
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(urlByUsername)) {
                System.out.println("根据用户名确定跳转页面: " + urlByUsername);
                log.info("根据用户名确定跳转页面: {}", urlByUsername);
                return urlByUsername;
            }
            
            // 3. 根据部门确定跳转页面
            String urlByDepartment = getRedirectUrlByDepartment(orgCode);
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(urlByDepartment)) {
                System.out.println("根据部门确定跳转页面: " + urlByDepartment);
                log.info("根据部门确定跳转页面: {}", urlByDepartment);
                return urlByDepartment;
            }
            
            // 4. 根据用户角色确定跳转页面
            String urlByRole = getRedirectUrlByRole(userInfo);
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(urlByRole)) {
                System.out.println("根据用户角色确定跳转页面: " + urlByRole);
                log.info("根据用户角色确定跳转页面: {}", urlByRole);
                return urlByRole;
            }
            
            // 5. 使用默认跳转页面
            String defaultUrl = getDefaultRedirectUrl();
            System.out.println("使用默认跳转页面: " + defaultUrl);
            log.info("使用默认跳转页面: {}", defaultUrl);
            return defaultUrl;
            
        } catch (Exception e) {
            System.out.println("确定跳转目标页面失败: " + e.getMessage());
            log.error("确定跳转目标页面失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("确定跳转目标页面失败", e);
            return getDefaultRedirectUrl();
        }
    }

    /**
     * 根据用户名确定跳转页面
     *
     * @param username 用户名
     * @return 跳转页面
     */
    private String getRedirectUrlByUsername(String username) {
        if (org.jeecg.common.util.oConvertUtils.isEmpty(username)) {
            return null;
        }
        
        // 管理员用户
        if ("admin".equals(username) || username.startsWith("admin_")) {
            return "/admin/dashboard";
        }
        
        // 护士用户
        if (username.startsWith("nurse_") || username.startsWith("lihang")) {
            return "/nurse/dashboard";
        }
        
        // 医生用户
        if (username.startsWith("doctor_")) {
            return "/doctor/dashboard";
        }
        
        // 患者用户
        if (username.startsWith("patient_")) {
            return "/patient/dashboard";
        }
        
        return null;
    }

    /**
     * 根据部门确定跳转页面
     *
     * @param orgCode 部门编码
     * @return 跳转页面
     */
    private String getRedirectUrlByDepartment(String orgCode) {
        if (org.jeecg.common.util.oConvertUtils.isEmpty(orgCode)) {
            return null;
        }
        
        switch (orgCode) {
            case "nurse_dept":
                return "/nurse/dashboard";
            case "doctor_dept":
                return "/doctor/dashboard";
            case "admin_dept":
                return "/admin/dashboard";
            case "patient_dept":
                return "/patient/dashboard";
            default:
                return null;
        }
    }

    /**
     * 根据用户角色确定跳转页面
     *
     * @param userInfo 用户信息
     * @return 跳转页面
     */
    private String getRedirectUrlByRole(JSONObject userInfo) {
        try {
            // 这里可以根据实际的角色字段来判断
            // 假设用户信息中有角色信息
            String roles = userInfo.getString("roles");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(roles)) {
                if (roles.contains("admin")) {
                    return "/admin/dashboard";
                } else if (roles.contains("nurse")) {
                    return "/nurse/dashboard";
                } else if (roles.contains("doctor")) {
                    return "/doctor/dashboard";
                } else if (roles.contains("patient")) {
                    return "/patient/dashboard";
                }
            }
            
            // 根据其他字段判断
            String userIdentity = userInfo.getString("userIdentity");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(userIdentity)) {
                switch (userIdentity) {
                    case "admin":
                        return "/admin/dashboard";
                    case "nurse":
                        return "/nurse/dashboard";
                    case "doctor":
                        return "/doctor/dashboard";
                    case "patient":
                        return "/patient/dashboard";
                    default:
                        break;
                }
            }
            
            return null;
            
        } catch (Exception e) {
            System.out.println("根据用户角色确定跳转页面失败: " + e.getMessage());
            log.error("根据用户角色确定跳转页面失败: {}", e.getMessage());
            return null;
        }
    }

    /**
     * 获取默认跳转页面
     *
     * @return 默认跳转页面
     */
    private String getDefaultRedirectUrl() {
        // 可以根据系统配置或环境变量来确定默认页面
        String defaultUrl = "/dashboard";
        
        // 这里可以从配置文件或环境变量中读取
        // String configUrl = systemConfigService.getConfigValue("default.redirect.url");
        // if (org.jeecg.common.util.oConvertUtils.isNotEmpty(configUrl)) {
        //     defaultUrl = configUrl;
        // }
        
        return defaultUrl;
    }








    /**
     * 设置用户默认角色
     * 根据原登录逻辑绑定部门和角色对应关系
     *
     * @param sysUser 系统用户
     * @return 设置结果
     */
    private boolean setUserDefaultRole(SysUser sysUser) {
        try {
            System.out.println("=== 设置用户默认角色 ===");
            log.info("=== 设置用户默认角色 ===");
            System.out.println("用户ID: " + sysUser.getId());
            log.info("用户ID: {}", sysUser.getId());
            System.out.println("用户名: " + sysUser.getUsername());
            log.info("用户名: {}", sysUser.getUsername());
            System.out.println("部门编码: " + sysUser.getOrgCode());
            log.info("部门编码: {}", sysUser.getOrgCode());
            
            // 1. 查找默认角色（普通用户）
            System.out.println("步骤1: 查找默认角色");
            log.info("步骤1: 查找默认角色");
            String defaultRoleCode = "普通用户";
            
            // 这里需要根据实际的角色服务来查找角色
            // 假设有角色服务可以查询角色
            // SysRole defaultRole = sysRoleService.getRoleByCode(defaultRoleCode);
            
            // 由于没有具体的角色服务，这里使用模拟的方式
            // 实际项目中需要注入相应的服务
            System.out.println("查找角色: " + defaultRoleCode);
            log.info("查找角色: {}", defaultRoleCode);
            
            // 2. 创建用户角色关联
            System.out.println("步骤2: 创建用户角色关联");
            log.info("步骤2: 创建用户角色关联");
            
            // 这里需要根据实际的用户角色关联服务来创建关联
            // 假设有用户角色关联服务
            // SysUserRole userRole = new SysUserRole();
            // userRole.setUserId(sysUser.getId());
            // userRole.setRoleId(defaultRole.getId());
            // boolean saveResult = sysUserRoleService.save(userRole);
            
            // 由于没有具体的服务，这里使用模拟的方式
            System.out.println("创建用户角色关联: 用户ID=" + sysUser.getId() + ", 角色=" + defaultRoleCode);
            log.info("创建用户角色关联: 用户ID={}, 角色={}", sysUser.getId(), defaultRoleCode);
            
            // 3. 设置用户角色信息到用户对象
            System.out.println("步骤3: 设置用户角色信息");
            log.info("步骤3: 设置用户角色信息");
            
            // 根据原登录逻辑，可能需要设置角色相关的字段
            // 这里设置一些常见的角色相关字段
            // sysUser.setRoles(defaultRoleCode); // 设置角色名称（如果SysUser有此字段）
            // sysUser.setRoleIds(defaultRole.getId()); // 设置角色ID（如果有此字段）
            
            // 由于SysUser可能没有setRoles方法，这里只记录日志
            System.out.println("用户角色信息: " + defaultRoleCode);
            log.info("用户角色信息: {}", defaultRoleCode);
            
            // 4. 更新用户信息
            System.out.println("步骤4: 更新用户信息");
            log.info("步骤4: 更新用户信息");
            boolean updateResult = sysUserService.updateById(sysUser);
            if (!updateResult) {
                System.out.println("更新用户角色信息失败");
                log.error("更新用户角色信息失败");
                return false;
            }
            
            System.out.println("用户角色设置成功");
            log.info("用户角色设置成功");
            return true;
            
        } catch (Exception e) {
            System.out.println("设置用户默认角色失败: " + e.getMessage());
            log.error("设置用户默认角色失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("设置用户默认角色失败", e);
            return false;
        }
    }

    /**
     * 确保默认部门存在
     * 如果默认部门不存在，则创建
     *
     * @param orgCode 部门编码
     * @param orgName 部门名称
     * @return 部门ID
     */
    private String ensureDefaultDepartment(String orgCode, String orgName) {
        try {
            System.out.println("=== 确保默认部门存在 ===");
            log.info("=== 确保默认部门存在 ===");
            System.out.println("部门编码: " + orgCode);
            log.info("部门编码: {}", orgCode);
            System.out.println("部门名称: " + orgName);
            log.info("部门名称: {}", orgName);
            
            // 1. 查找部门是否存在
            System.out.println("步骤1: 查找部门是否存在");
            log.info("步骤1: 查找部门是否存在");
            
            // 这里需要根据实际的部门服务来查找部门
            // 假设有部门服务可以查询部门
            // LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
            // queryWrapper.eq(SysDepart::getOrgCode, orgCode);
            // SysDepart existDept = sysDepartService.getOne(queryWrapper);
            
            // 由于没有具体的部门服务，这里使用模拟的方式
            System.out.println("查找部门: " + orgCode);
            log.info("查找部门: {}", orgCode);
            
            // 2. 如果部门不存在，创建部门
            System.out.println("步骤2: 检查部门是否存在");
            log.info("步骤2: 检查部门是否存在");
            
            // 模拟部门存在的情况
            boolean deptExists = true; // 假设部门已存在
            
            if (!deptExists) {
                System.out.println("部门不存在，创建新部门");
                log.info("部门不存在，创建新部门");
                
                // 创建新部门
                // SysDepart newDept = new SysDepart();
                // newDept.setOrgCode(orgCode);
                // newDept.setOrgName(orgName);
                // newDept.setParentId("0"); // 根部门
                // newDept.setOrgCategory("1"); // 公司
                // newDept.setOrgType("1"); // 机构
                // newDept.setSortOrder(0);
                // newDept.setStatus(1);
                // newDept.setDelFlag(0);
                // newDept.setCreateTime(new Date());
                // newDept.setUpdateTime(new Date());
                // 
                // boolean saveResult = sysDepartService.save(newDept);
                // if (saveResult) {
                //     System.out.println("部门创建成功: " + newDept.getId());
                //     log.info("部门创建成功: {}", newDept.getId());
                //     return newDept.getId();
                // } else {
                //     System.out.println("部门创建失败");
                //     log.error("部门创建失败");
                //     return null;
                // }
            } else {
                System.out.println("部门已存在: " + orgCode);
                log.info("部门已存在: {}", orgCode);
            }
            
            // 返回部门ID（模拟）
            String deptId = "dept_" + orgCode;
            System.out.println("返回部门ID: " + deptId);
            log.info("返回部门ID: {}", deptId);
            return deptId;
            
        } catch (Exception e) {
            System.out.println("确保默认部门存在失败: " + e.getMessage());
            log.error("确保默认部门存在失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("确保默认部门存在失败", e);
            return null;
        }
    }

    /**
     * 用户信息处理，参照LoginController的userInfo方法
     *
     * @param sysUser 系统用户
     * @param result 结果对象
     * @param request HTTP请求
     * @return 登录结果
     */
    private Result<JSONObject> userInfo(SysUser sysUser, Result<JSONObject> result, HttpServletRequest request) {
        System.out.println("=== 用户信息处理流程开始 ===");
        log.info("=== 用户信息处理流程开始 ===");
        System.out.println("系统用户: " + sysUser.getUsername());
        log.info("系统用户: {}", sysUser.getUsername());
        
        String username = sysUser.getUsername();
        String syspassword = sysUser.getPassword();
        
        // 获取用户部门信息
        JSONObject obj = new JSONObject();

        // 1. 生成token
        System.out.println("步骤1: 生成JWT token");
        log.info("步骤1: 生成JWT token");
        String token = JwtUtil.sign(username, syspassword);
        System.out.println("生成的token: " + token);
        log.info("生成的token: {}", token);
        
        // 设置token缓存有效时间
        System.out.println("步骤2: 设置token到Redis");
        log.info("步骤2: 设置token到Redis");
        redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
        redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME * 2 / 1000);
        System.out.println("token已设置到Redis，过期时间: " + (JwtUtil.EXPIRE_TIME * 2 / 1000) + "秒");
        log.info("token已设置到Redis，过期时间: {}秒", (JwtUtil.EXPIRE_TIME * 2 / 1000));
        obj.put("token", token);

        // 2. 设置登录租户
        System.out.println("步骤3: 设置登录租户");
        log.info("步骤3: 设置登录租户");
        Result<JSONObject> loginTenantError = sysUserService.setLoginTenant(sysUser, obj, username, result);
        if (loginTenantError != null) {
            System.out.println("设置登录租户失败: " + loginTenantError.getMessage());
            log.error("设置登录租户失败: {}", loginTenantError.getMessage());
            return loginTenantError;
        }
        System.out.println("登录租户设置成功");
        log.info("登录租户设置成功");

        // 3. 设置登录用户信息
        System.out.println("步骤4: 设置登录用户信息");
        log.info("步骤4: 设置登录用户信息");
        obj.put("userInfo", sysUser);
        System.out.println("用户信息已设置");
        log.info("用户信息已设置");

        // 4. 设置登录部门
        System.out.println("步骤5: 设置登录部门");
        log.info("步骤5: 设置登录部门");
        List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
        System.out.println("用户部门数量: " + (departs != null ? departs.size() : 0));
        log.info("用户部门数量: {}", (departs != null ? departs.size() : 0));
        obj.put("departs", departs);
        
        if (departs == null || departs.size() == 0) {
            System.out.println("用户无部门信息");
            log.info("用户无部门信息");
            obj.put("multi_depart", 0);
        } else if (departs.size() == 1) {
            System.out.println("用户只有一个部门，自动设置: " + departs.get(0).getOrgCode());
            log.info("用户只有一个部门，自动设置: {}", departs.get(0).getOrgCode());
            sysUserService.updateUserDepart(username, departs.get(0).getOrgCode(), null);
            obj.put("multi_depart", 1);
        } else {
            System.out.println("用户有多个部门，检查当前登录部门");
            log.info("用户有多个部门，检查当前登录部门");
            // 查询当前是否有登录部门
            SysUser sysUserById = sysUserService.getById(sysUser.getId());
            System.out.println("当前用户部门: " + sysUserById.getOrgCode());
            log.info("当前用户部门: {}", sysUserById.getOrgCode());
            
            if (org.jeecg.common.util.oConvertUtils.isEmpty(sysUserById.getOrgCode())) {
                System.out.println("用户没有部门信息，设置第一个部门: " + departs.get(0).getOrgCode());
                log.info("用户没有部门信息，设置第一个部门: {}", departs.get(0).getOrgCode());
                sysUserService.updateUserDepart(username, departs.get(0).getOrgCode(), null);
            }
            obj.put("multi_depart", 2);
            System.out.println("多部门用户，需要用户选择");
            log.info("多部门用户，需要用户选择");
        }

        System.out.println("步骤6: 构建返回结果");
        log.info("步骤6: 构建返回结果");
        result.setResult(obj);
        result.success("登录成功");
        
        System.out.println("用户信息处理完成，返回结果");
        log.info("用户信息处理完成，返回结果");
        return result;
    }

    /**
     * 企业微信用户绑定接口（管理员手动绑定）
     * 用于管理员手动绑定企业微信用户ID和系统用户
     *
     * @param request 绑定请求
     * @return 绑定结果
     */
    @AutoLog(value = "企业微信-管理员手动绑定")
    @PostMapping("/oauth2/wechat_enterprise/bind")
    @ApiOperation(value = "企业微信用户绑定", notes = "管理员手动绑定企业微信用户ID和系统用户")
    public Result<String> bindWechatUser(@RequestBody JSONObject request) {
        try {
            System.out.println("=== 管理员手动绑定流程开始 ===");
            log.info("=== 管理员手动绑定流程开始 ===");
            String wechatUserId = request.getString("wechatUserId");
            String username = request.getString("username");
            
            System.out.println("企业微信用户ID: " + wechatUserId);
            log.info("企业微信用户ID: {}", wechatUserId);
            System.out.println("系统用户名: " + username);
            log.info("系统用户名: {}", username);
            
            if (org.jeecg.common.util.oConvertUtils.isEmpty(wechatUserId) || 
                org.jeecg.common.util.oConvertUtils.isEmpty(username)) {
                System.out.println("参数验证失败：参数不能为空");
                log.error("参数验证失败：参数不能为空");
                return Result.error("参数不能为空");
            }
            
            // 查找系统用户
            System.out.println("步骤1: 查找系统用户");
            log.info("步骤1: 查找系统用户");
            LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUser::getUsername, username);
            SysUser sysUser = sysUserService.getOne(queryWrapper);
            
            if (sysUser == null) {
                System.out.println("用户不存在: " + username);
                log.error("用户不存在: {}", username);
                return Result.error("用户不存在");
            }
            System.out.println("找到系统用户: " + sysUser.getUsername());
            log.info("找到系统用户: {}", sysUser.getUsername());
            
            // 检查是否已经绑定
            System.out.println("步骤2: 检查是否已经绑定");
            log.info("步骤2: 检查是否已经绑定");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(sysUser.getWechatUserid())) {
                System.out.println("该用户已绑定企业微信账号: " + sysUser.getWechatUserid());
                log.warn("该用户已绑定企业微信账号: {}", sysUser.getWechatUserid());
                return Result.error("该用户已绑定企业微信账号");
            }
            System.out.println("用户未绑定企业微信账号");
            log.info("用户未绑定企业微信账号");
            
            // 检查企业微信用户ID是否已被其他用户绑定
            System.out.println("步骤3: 检查企业微信用户ID是否已被其他用户绑定");
            log.info("步骤3: 检查企业微信用户ID是否已被其他用户绑定");
            LambdaQueryWrapper<SysUser> checkWrapper = new LambdaQueryWrapper<>();
            checkWrapper.eq(SysUser::getWechatUserid, wechatUserId);
            SysUser existUser = sysUserService.getOne(checkWrapper);
            if (existUser != null) {
                System.out.println("该企业微信账号已被其他用户绑定: " + existUser.getUsername());
                log.warn("该企业微信账号已被其他用户绑定: {}", existUser.getUsername());
                return Result.error("该企业微信账号已被其他用户绑定");
            }
            System.out.println("企业微信用户ID未被其他用户绑定");
            log.info("企业微信用户ID未被其他用户绑定");
            
            // 绑定企业微信用户ID
            System.out.println("步骤4: 执行绑定操作");
            log.info("步骤4: 执行绑定操作");
            sysUser.setWechatUserid(wechatUserId);
            sysUserService.updateById(sysUser);
            
            System.out.println("绑定成功: " + username + " -> " + wechatUserId);
            log.info("绑定成功: {} -> {}", username, wechatUserId);
            log.info("管理员手动绑定用户 {} 到企业微信账号 {}", username, wechatUserId);
            return Result.OK("绑定成功");
            
        } catch (Exception e) {
            System.out.println("企业微信用户绑定失败: " + e.getMessage());
            log.error("企业微信用户绑定失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("企业微信用户绑定失败", e);
            return Result.error("绑定失败：" + e.getMessage());
        }
    }

    /**
     * 处理登录成功后的页面跳转（前端调用）
     * 前端可以通过此接口获取跳转信息
     *
     * @param request HTTP请求
     * @return 跳转信息
     */
    @AutoLog(value = "企业微信-获取跳转信息")
    @GetMapping("/oauth2/wechat_enterprise/redirect")
    @ApiOperation(value = "获取登录后跳转信息", notes = "获取企业微信登录成功后的页面跳转信息")
    public Result<JSONObject> getRedirectInfo(HttpServletRequest request) {
        try {
            System.out.println("=== 获取登录后跳转信息 ===");
            log.info("=== 获取登录后跳转信息 ===");
            
            // 从请求头中获取token
            String token = request.getHeader("Authorization");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(token) && token.startsWith("Bearer ")) {
                token = token.substring(7);
            }
            
            if (org.jeecg.common.util.oConvertUtils.isEmpty(token)) {
                System.out.println("未找到有效的token");
                log.warn("未找到有效的token");
                return Result.error("未找到有效的token");
            }
            
            // 验证token并获取用户信息
            String username = JwtUtil.getUsername(token);
            if (org.jeecg.common.util.oConvertUtils.isEmpty(username)) {
                System.out.println("token无效或已过期");
                log.warn("token无效或已过期");
                return Result.error("token无效或已过期");
            }
            
            // 获取用户信息
            LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUser::getUsername, username);
            SysUser sysUser = sysUserService.getOne(queryWrapper);
            
            if (sysUser == null) {
                System.out.println("用户不存在: " + username);
                log.warn("用户不存在: {}", username);
                return Result.error("用户不存在");
            }
            
            // 检查用户状态
            if (sysUser.getStatus() != 1) {
                System.out.println("用户已被禁用: " + username);
                log.warn("用户已被禁用: {}", username);
                return Result.error("用户已被禁用");
            }
            
            // 确定跳转目标页面
            String redirectUrl = determineRedirectUrl(null, username, sysUser.getRealname(), sysUser.getOrgCode(), null);
            System.out.println("确定跳转目标页面: " + redirectUrl);
            log.info("确定跳转目标页面: {}", redirectUrl);
            
            // 构建返回结果
            JSONObject result = new JSONObject();
            result.put("redirectUrl", redirectUrl);
            result.put("redirectType", "success");
            result.put("username", username);
            result.put("realname", sysUser.getRealname());
            result.put("orgCode", sysUser.getOrgCode());
            
            System.out.println("跳转信息获取成功");
            log.info("跳转信息获取成功");
            return Result.OK("获取成功", result);
            
        } catch (Exception e) {
            System.out.println("获取跳转信息失败: " + e.getMessage());
            log.error("获取跳转信息失败: {}", e.getMessage());
            e.printStackTrace();
            log.error("获取跳转信息失败", e);
            return Result.error("获取跳转信息失败：" + e.getMessage());
        }
    }

    /**
     * 获取企业微信配置信息
     *
     * @return 配置信息
     */
    @AutoLog(value = "企业微信-获取配置信息")
    @GetMapping("/config")
    @ApiOperation(value = "获取企业微信配置信息", notes = "获取企业微信相关配置信息")
    public Result<Object> getWechatConfig() {
        try {
            // 构建配置信息（不包含敏感信息）
            java.util.Map<String, Object> config = new java.util.HashMap<>();
            config.put("corpId", corpId);
            config.put("agentId", agentId);
            config.put("redirectUri", redirectUri);
            config.put("hasToken", token != null && !token.trim().isEmpty());
            config.put("hasSecret", secret != null && !secret.trim().isEmpty());
            
            return Result.OK("获取配置成功", config);
            
        } catch (Exception e) {
            log.error("获取企业微信配置失败", e);
            return Result.error("获取配置失败：" + e.getMessage());
        }
    }

    /**
     * 获取企业微信用户信息（用于调试和绑定）
     * 管理员可以通过此接口查看企业微信用户信息，便于手动绑定
     *
     * @param wechatUserId 企业微信用户ID
     * @return 用户信息
     */
    @AutoLog(value = "企业微信-获取用户信息")
    @GetMapping("/oauth2/wechat_enterprise/userinfo")
    @ApiOperation(value = "获取企业微信用户信息", notes = "获取企业微信用户详细信息，用于调试和绑定")
    public Result<JSONObject> getWechatUserInfo(@RequestParam("wechatUserId") String wechatUserId) {
        try {
            System.out.println("=== 获取企业微信用户信息 ===");
            log.info("=== 获取企业微信用户信息 ===");
            System.out.println("企业微信用户ID: " + wechatUserId);
            log.info("企业微信用户ID: {}", wechatUserId);
            
            // 1. 获取access_token
            System.out.println("步骤1: 获取access_token");
            log.info("步骤1: 获取access_token");
            String accessTokenUrl = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=" + corpId + "&corpsecret=" + secret;
            String accessTokenResponse = String.valueOf(org.jeecg.common.util.RestUtil.get(accessTokenUrl));
            JSONObject accessTokenJson = JSONObject.parseObject(accessTokenResponse);
            
            if (accessTokenJson.getInteger("errcode") != 0) {
                System.out.println("获取access_token失败: " + accessTokenJson.getString("errmsg"));
                log.error("获取access_token失败: {}", accessTokenJson.getString("errmsg"));
                return Result.error("获取access_token失败: " + accessTokenJson.getString("errmsg"));
            }
            
            String accessToken = accessTokenJson.getString("access_token");
            System.out.println("成功获取access_token");
            log.info("成功获取access_token");
            
            // 2. 获取用户详细信息
            System.out.println("步骤2: 获取用户详细信息");
            log.info("步骤2: 获取用户详细信息");
            String userDetailUrl = "https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=" + accessToken + "&userid=" + wechatUserId;
            String userDetailResponse = String.valueOf(org.jeecg.common.util.RestUtil.get(userDetailUrl));
            JSONObject userDetailJson = JSONObject.parseObject(userDetailResponse);
            
            if (userDetailJson.getInteger("errcode") != 0) {
                System.out.println("获取用户详细信息失败: " + userDetailJson.getString("errmsg"));
                log.error("获取用户详细信息失败: {}", userDetailJson.getString("errmsg"));
                return Result.error("获取用户详细信息失败: " + userDetailJson.getString("errmsg"));
            }
            
            System.out.println("成功获取用户详细信息");
            log.info("成功获取用户详细信息");
            
            // 3. 检查系统用户匹配情况
            System.out.println("步骤3: 检查系统用户匹配情况");
            log.info("步骤3: 检查系统用户匹配情况");
            JSONObject result = new JSONObject();
            result.put("wechatUserInfo", userDetailJson);
            
            // 检查手机号匹配
            String mobile = userDetailJson.getString("mobile");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(mobile)) {
                LambdaQueryWrapper<SysUser> mobileQuery = new LambdaQueryWrapper<>();
                mobileQuery.eq(SysUser::getPhone, mobile);
                SysUser mobileUser = sysUserService.getOne(mobileQuery);
                result.put("mobileMatch", mobileUser != null ? mobileUser.getUsername() : null);
            }
            
            // 检查邮箱匹配
            String email = userDetailJson.getString("email");
            if (org.jeecg.common.util.oConvertUtils.isNotEmpty(email)) {
                LambdaQueryWrapper<SysUser> emailQuery = new LambdaQueryWrapper<>();
                emailQuery.eq(SysUser::getEmail, email);
                SysUser emailUser = sysUserService.getOne(emailQuery);
                result.put("emailMatch", emailUser != null ? emailUser.getUsername() : null);
            }
            
            // 检查用户名匹配
            LambdaQueryWrapper<SysUser> usernameQuery = new LambdaQueryWrapper<>();
            usernameQuery.eq(SysUser::getUsername, wechatUserId);
            SysUser usernameUser = sysUserService.getOne(usernameQuery);
            result.put("usernameMatch", usernameUser != null ? usernameUser.getUsername() : null);
            
            System.out.println("用户信息获取完成");
            log.info("用户信息获取完成");
            return Result.OK("获取成功", result);
            
        } catch (Exception e) {
            System.out.println("获取企业微信用户信息失败: " + e.getMessage());
            log.error("获取企业微信用户信息失败: {}", e.getMessage());
            e.printStackTrace();
            return Result.error("获取失败：" + e.getMessage());
        }
    }

    /**
     * 批量绑定企业微信用户
     * 管理员可以通过此接口批量绑定企业微信用户
     *
     * @param request 批量绑定请求
     * @return 绑定结果
     */
    @AutoLog(value = "企业微信-批量绑定用户")
    @PostMapping("/oauth2/wechat_enterprise/batch-bind")
    @ApiOperation(value = "批量绑定企业微信用户", notes = "管理员批量绑定企业微信用户ID和系统用户")
    public Result<JSONObject> batchBindWechatUser(@RequestBody JSONObject request) {
        try {
            System.out.println("=== 批量绑定企业微信用户 ===");
            log.info("=== 批量绑定企业微信用户 ===");
            
            com.alibaba.fastjson.JSONArray bindList = request.getJSONArray("bindList");
            if (bindList == null || bindList.isEmpty()) {
                return Result.error("绑定列表不能为空");
            }
            
            JSONObject result = new JSONObject();
            com.alibaba.fastjson.JSONArray successList = new com.alibaba.fastjson.JSONArray();
            com.alibaba.fastjson.JSONArray failList = new com.alibaba.fastjson.JSONArray();
            
            for (int i = 0; i < bindList.size(); i++) {
                JSONObject bindItem = bindList.getJSONObject(i);
                String wechatUserId = bindItem.getString("wechatUserId");
                String username = bindItem.getString("username");
                
                System.out.println("处理绑定项 " + (i + 1) + ": " + wechatUserId + " -> " + username);
                log.info("处理绑定项 {}: {} -> {}", (i + 1), wechatUserId, username);
                
                try {
                    // 查找系统用户
                    LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(SysUser::getUsername, username);
                    SysUser sysUser = sysUserService.getOne(queryWrapper);
                    
                    if (sysUser == null) {
                        failList.add(new JSONObject() {{
                            put("wechatUserId", wechatUserId);
                            put("username", username);
                            put("error", "用户不存在");
                        }});
                        continue;
                    }
                    
                    // 检查是否已经绑定
                    if (org.jeecg.common.util.oConvertUtils.isNotEmpty(sysUser.getWechatUserid())) {
                        failList.add(new JSONObject() {{
                            put("wechatUserId", wechatUserId);
                            put("username", username);
                            put("error", "该用户已绑定企业微信账号");
                        }});
                        continue;
                    }
                    
                    // 检查企业微信用户ID是否已被其他用户绑定
                    LambdaQueryWrapper<SysUser> checkWrapper = new LambdaQueryWrapper<>();
                    checkWrapper.eq(SysUser::getWechatUserid, wechatUserId);
                    SysUser existUser = sysUserService.getOne(checkWrapper);
                    if (existUser != null) {
                        failList.add(new JSONObject() {{
                            put("wechatUserId", wechatUserId);
                            put("username", username);
                            put("error", "该企业微信账号已被其他用户绑定");
                        }});
                        continue;
                    }
                    
                    // 执行绑定
                    sysUser.setWechatUserid(wechatUserId);
                    sysUserService.updateById(sysUser);
                    
                    successList.add(new JSONObject() {{
                        put("wechatUserId", wechatUserId);
                        put("username", username);
                        put("status", "绑定成功");
                    }});
                    
                    System.out.println("绑定成功: " + username + " -> " + wechatUserId);
                    log.info("绑定成功: {} -> {}", username, wechatUserId);
                    
                } catch (Exception e) {
                    failList.add(new JSONObject() {{
                        put("wechatUserId", wechatUserId);
                        put("username", username);
                        put("error", "绑定失败: " + e.getMessage());
                    }});
                    System.out.println("绑定失败: " + username + " -> " + wechatUserId + ", 错误: " + e.getMessage());
                    log.error("绑定失败: {} -> {}, 错误: {}", username, wechatUserId, e.getMessage());
                }
            }
            
            result.put("successList", successList);
            result.put("failList", failList);
            result.put("totalCount", bindList.size());
            result.put("successCount", successList.size());
            result.put("failCount", failList.size());
            
            System.out.println("批量绑定完成，成功: " + successList.size() + ", 失败: " + failList.size());
            log.info("批量绑定完成，成功: {}, 失败: {}", successList.size(), failList.size());
            return Result.OK("批量绑定完成", result);
            
        } catch (Exception e) {
            System.out.println("批量绑定失败: " + e.getMessage());
            log.error("批量绑定失败: {}", e.getMessage());
            e.printStackTrace();
            return Result.error("批量绑定失败：" + e.getMessage());
        }
    }
} 